/*
 * ============================================================================
 *
 *  Zombie:Reloaded
 *
 *  File:          apply.inc
 *  Type:          Core
 *  Description:   Functions for applying attributes and effects on a client.
 *
 *  Copyright (C) 2009  Greyscale, Richard Helgeby
 *
 *  This program is free software: you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation, either version 3 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *
 * ============================================================================
 */

/**
 * Array that stores the client's current speed.
 */
new Float:g_flClassApplySpeed[MAXPLAYERS + 1];

/**
 * Applies all class attributes on a player. Changing model, hp, speed, health,
 * effects etc. The players current team will be used to get the class index.
 *
 * @param client        The player to apply attributes on.
 * @param improved      Optional. Gives advantages or improvements in some
 *                      attributes. To be used on mother zombies. Default is
 *                      false.
 * @return  True if all success on applying all attributes, false otherwise.
 */
bool:ClassApplyAttributes(client, bool:improved = false)
{
    new classindex = ClassGetActiveIndex(client);
    
    // Validate class index.
    if (!ClassValidateIndex(classindex))
    {
        return false;
    }
    
    // Override improved settings if it's a mother zombie class.
    if (ClassHasFlags(classindex, ZR_CLASS_FLAG_MOTHER_ZOMBIE))
    {
        improved = false;
    }
    
    ClassApplyModel(client, classindex);
    ClassApplyAlpha(client, classindex);
    ClassApplyOverlay(client, classindex);
    ClassApplyNightVision(client, classindex);
    ClassApplyFOV(client, classindex);
    ClassApplyHealth(client, classindex, improved);
    ClassApplyHealthRegen(client, classindex);
    ClassApplySpeed(client, classindex);
    
    return true;
}

/**
 * Changes the model on a player.
 *
 * @param client        The client index.
 * @param classindex    The class to read from.
 * @param cachetype     Optional. Specifies what class cache to read from.
 *                      Options:
 *                      ZR_CLASS_CACHE_ORIGINAL - Unchanced class data.
 *                      ZR_CLASS_CACHE_MODIFIED - Changed/newest class data.
 *                      ZR_CLASS_CACHE_PLAYER (default) - Player cache.
 * @return  True on success, false otherwise.
 */
bool:ClassApplyModel(client, classindex, cachetype = ZR_CLASS_CACHE_PLAYER)
{
    new bool:isAttributePreset = false;
    decl String:modelpath[PLATFORM_MAX_PATH];
    new index;
    new ModelTeam:team;
    new access;
    new model;
    
    // Get correct index according to cache type.
    if (cachetype == ZR_CLASS_CACHE_PLAYER)
    {
        index = client;
    }
    else
    {
        index = classindex;
    }
    
    // Get the model path from the specified cache.
    ClassGetModelPath(index, modelpath, sizeof(modelpath), cachetype);
    
    // Get model team setting from the specified cache.
    team = ModelsTeamIdToTeam(ClassGetTeamID(index, cachetype));
    
    // Check if the user specified a pre-defined model setting. If so, setup
    // model filter settings.
    if (StrEqual(modelpath, "random", false))
    {
        // Set access filter flags.
        access = MODEL_ACCESS_PUBLIC | MODEL_ACCESS_ADMINS;
        
        // Specify client for including admin models if client is admin.
        index = client;
        
        isAttributePreset = true;
    }
    else if (StrEqual(modelpath, "random_public", false))
    {
        access = MODEL_ACCESS_PUBLIC;
        index = -1;
        isAttributePreset = true;
    }
    else if (StrEqual(modelpath, "random_hidden", false))
    {
        access = MODEL_ACCESS_HIDDEN;
        index = -1;
        isAttributePreset = true;
    }
    else if (StrEqual(modelpath, "random_admin", false))
    {
        access = MODEL_ACCESS_ADMINS;
        index = -1;
        isAttributePreset = true;
    }
    else if (StrEqual(modelpath, "random_mother_zombie", false))
    {
        access = MODEL_ACCESS_MOTHER_ZOMBIES;
        index = -1;
        isAttributePreset = true;
    }
    else if (StrEqual(modelpath, "default", false))
    {
        // Get current model.
        GetClientModel(client, modelpath, sizeof(modelpath));
        
        // Restore original model if not already set.
        if (!StrEqual(ClassOriginalPlayerModel[client], modelpath))
        {
            strcopy(modelpath, sizeof(modelpath), ClassOriginalPlayerModel[client]);
        }
        else
        {
            // Wanted model is already set, don't change.
            return true;
        }
    }
    else if (StrEqual(modelpath, "no_change", false))
    {
        // Do nothing.
        return true;
    }
    
    // Check if model setting is a attribute preset.
    if (isAttributePreset)
    {
        // Get model based on filter settings set up earlier.
        model = ModelsGetRandomModel(index, team, access);
        
        // Check if found.
        if (model >= 0)
        {
            // Get model path.
            ModelsGetFullPath(model, modelpath, sizeof(modelpath));
        }
        else
        {
            // Couldn't find any models based on filter. Fall back to a random
            // public model. Then get its path.
            model = ModelsGetRandomModel(-1, team, MODEL_ACCESS_PUBLIC);
            ModelsGetFullPath(model, modelpath, sizeof(modelpath));
        }
    }
    
    SetEntityModel(client, modelpath);
    return true;
}

/**
 * Sets transparency on a player.
 *
 * @param client        The client index.
 * @param classindex    The class to read from.
 * @param cachetype     Optional. Specifies what class cache to read from.
 *                      Options:
 *                      ZR_CLASS_CACHE_ORIGINAL - Unchanced class data.
 *                      ZR_CLASS_CACHE_MODIFIED - Changed/newest class data.
 *                      ZR_CLASS_CACHE_PLAYER (default) - Player cache.
 * @return  True on success, false otherwise.
 */
bool:ClassApplyAlpha(client, classindex, cachetype = ZR_CLASS_CACHE_PLAYER)
{
    new alpha;
    
    // Get the alpha value from the specified cache.
    if (cachetype == ZR_CLASS_CACHE_PLAYER)
    {
        alpha = ClassGetAlphaInitial(client, cachetype);
    }
    else
    {
        alpha = ClassGetAlphaInitial(classindex, cachetype);
    }
    
    if (alpha < 0)
    {
        return false;
    }
    
    ToolsSetClientAlpha(client, alpha);
    return true;
}

/**
 * Apply the overlay on a player if not applied.
 *
 * @param client        The client index.
 * @param classindex    The class to read from.
 * @param cachetype     Optional. Specifies what class cache to read from.
 *                      Options:
 *                      ZR_CLASS_CACHE_ORIGINAL - Unchanced class data.
 *                      ZR_CLASS_CACHE_MODIFIED - Changed/newest class data.
 *                      ZR_CLASS_CACHE_PLAYER (default) - Player cache.
 * @return  True on success, false otherwise.
 */
bool:ClassApplyOverlay(client, classindex, cachetype = ZR_CLASS_CACHE_PLAYER)
{
    decl String:overlaypath[PLATFORM_MAX_PATH];
    
    // Get the overlay path from the specified cache.
    if (cachetype == ZR_CLASS_CACHE_PLAYER)
    {
        ClassGetOverlayPath(client, overlaypath, sizeof(overlaypath), cachetype);
    }
    else
    {
        ClassGetOverlayPath(classindex, overlaypath, sizeof(overlaypath), cachetype);
    }
    
    ClassOverlayInitialize(client, overlaypath);
    return true;
}

/**
 * Gives night vision to a player.
 *
 * @param client        The client index.
 * @param classindex    The class to read from.
 * @param cachetype     Optional. Specifies what class cache to read from.
 *                      Options:
 *                      ZR_CLASS_CACHE_ORIGINAL - Unchanced class data.
 *                      ZR_CLASS_CACHE_MODIFIED - Changed/newest class data.
 *                      ZR_CLASS_CACHE_PLAYER (default) - Player cache.
 * @return  True on success, false otherwise.
 */
bool:ClassApplyNightVision(client, classindex, cachetype = ZR_CLASS_CACHE_PLAYER)
{
    new bool:nvgs;
    
    // Get the night vision setting from the specified cache.
    if (cachetype == ZR_CLASS_CACHE_PLAYER)
    {
        nvgs = ClassGetNvgs(client, cachetype);
    }
    else
    {
        nvgs = ClassGetNvgs(classindex, cachetype);
    }
    
    ToolsSetClientNightVision(client, nvgs);
    ToolsSetClientNightVision(client, nvgs, false);
    
    return true;
}

/**
 * Sets the field of view setting on a player.
 *
 * @param client        The client index.
 * @param classindex    The class to read from.
 * @param cachetype     Optional. Specifies what class cache to read from.
 *                      Options:
 *                      ZR_CLASS_CACHE_ORIGINAL - Unchanced class data.
 *                      ZR_CLASS_CACHE_MODIFIED - Changed/newest class data.
 *                      ZR_CLASS_CACHE_PLAYER (default) - Player cache.
 * @return  True on success, false otherwise.
 */
bool:ClassApplyFOV(client, classindex, cachetype = ZR_CLASS_CACHE_PLAYER)
{
    new fov;
    
    // Get the field of view setting from the specified cache.
    if (cachetype == ZR_CLASS_CACHE_PLAYER)
    {
        fov = ClassGetFOV(client, cachetype);
    }
    else
    {
        fov = ClassGetFOV(classindex, cachetype);
    }
    
    ToolsSetClientDefaultFOV(client, fov);
    return true;
}

/**
 * Gives health points on a player.
 *
 * @param client        The client index.
 * @param classindex    The class to read from.
 * @param boost         Double health boost. Default: false
 * @param cachetype     Optional. Specifies what class cache to read from.
 *                      Options:
 *                      ZR_CLASS_CACHE_ORIGINAL - Unchanced class data.
 *                      ZR_CLASS_CACHE_MODIFIED - Changed/newest class data.
 *                      ZR_CLASS_CACHE_PLAYER (default) - Player cache.
 * @return  True on success, false otherwise.
 */
bool:ClassApplyHealth(client, classindex, bool:boost = false, cachetype = ZR_CLASS_CACHE_PLAYER)
{
    new health;
    
    // Get the health points from the specified cache.
    if (cachetype == ZR_CLASS_CACHE_PLAYER)
    {
        health = ClassGetHealth(client, cachetype);
    }
    else
    {
        health = ClassGetHealth(classindex, cachetype);
    }
    
    if (boost)
    {
        health *= 2;
    }
    
    SetEntityHealth(client, health);
    return true;
}

/**
 * Applies health regeneration on a player if enabled.
 *
 * @param client        The client index.
 * @param classindex    The class to read from.
 * @param boost         Double health boost. Default: false
 * @param cachetype     Optional. Specifies what class cache to read from.
 *                      Options:
 *                      ZR_CLASS_CACHE_ORIGINAL - Unchanced class data.
 *                      ZR_CLASS_CACHE_MODIFIED - Changed/newest class data.
 *                      ZR_CLASS_CACHE_PLAYER (default) - Player cache.
 * @return  True if applied, false otherwise.
 */
bool:ClassApplyHealthRegen(client, classindex, cachetype = ZR_CLASS_CACHE_PLAYER)
{
    new Float:interval;
    new amount;
    new max;
    
    // Get the health regeneration info from the specified cache.
    if (cachetype == ZR_CLASS_CACHE_PLAYER)
    {
        interval = ClassGetHealthRegenInterval(client, cachetype);
        amount = ClassGetHealthRegenAmount(client, cachetype);
        max = ClassGetHealth(client, cachetype);
    }
    else
    {
        interval = ClassGetHealthRegenInterval(classindex, cachetype);
        amount = ClassGetHealthRegenAmount(classindex, cachetype);
        max = ClassGetHealth(classindex, cachetype);
    }
    
    if (interval > 0)
    {
        ClassHealthRegenInitClient(client, interval, amount, max);
        return true;
    }
    else
    {
        // Make sure old timers are stopped.
        ClassHealthRegenStop(client);
        return false;
    }
}

/**
 * Sets the players speed.
 *
 * @param client        The client index.
 * @param classindex    The class to read from.
 * @param cachetype     Optional. Specifies what class cache to read from.
 *                      Options:
 *                      ZR_CLASS_CACHE_ORIGINAL - Unchanced class data.
 *                      ZR_CLASS_CACHE_MODIFIED - Changed/newest class data.
 *                      ZR_CLASS_CACHE_PLAYER (default) - Player cache.
 * @return  True on success, false otherwise.
 */
bool:ClassApplySpeed(client, classindex, cachetype = ZR_CLASS_CACHE_PLAYER)
{
    new Float:speed;
    
    // Get the health points from the specified cache.
    if (cachetype == ZR_CLASS_CACHE_PLAYER)
    {
        speed = ClassGetSpeed(client, cachetype);
    }
    else
    {
        speed = ClassGetSpeed(classindex, cachetype);
    }
    
    ClassApplySpeedEx(client, speed);
    return true;
}

/**
 * Applies the specified speed to the player.
 *
 * @param client    Client to apply to.
 * @param speed     Speed value.
 */
ClassApplySpeedEx(client, Float:speed)
{
    // Check what speed method that's used and apply it.
    switch (ClassSpeedMethod)
    {
        case ClassSpeed_LMV:
        {
            ToolsSetClientLMV(client, speed);
        }
        case ClassSpeed_Prop:
        {
            g_flClassApplySpeed[client] = speed;
        }
    }
}

/**
 * Called before the client can "think"
 * Here we can change the client's speed through m_flMaxSpeed.
 * 
 * @param client    The client index.
 */
public ClassPreThinkPost(client)
{
    // Only apply speed if the prop method is used.
    if (ClassSpeedMethod == ClassSpeed_Prop)
    {
        if (!IsPlayerAlive(client))
        {
            return;
        }
        
        // Note: Default is around 200.0 - 250.0
        new Float:newspeed = GetEntPropFloat(client, Prop_Data, "m_flMaxspeed") + g_flClassApplySpeed[client];
        SetEntPropFloat(client, Prop_Data, "m_flMaxspeed", newspeed);
    }
}

/**
 * Called when a clients movement buttons are being processed
 *
 * @param client	Index of the client.
 * @param vel		Players desired velocity.
 */
Class_OnPlayerRunCmd(client, Float:vel[3])
{
    if (!IsPlayerAlive(client))
        return;
    
    // Only modify speed if the prop method is used.
    if (ClassSpeedMethod == ClassSpeed_Prop)
    {
        // x-axis speed.
        if (vel[0] < 0.0)
            vel[0] = -5000.0;
        
        else if (vel[0] > 0.0)
            vel[0] = 5000.0;
        
        // y-axis speed.
        if (vel[1] < 0.0)
            vel[1] = -5000.0;
        
        else if (vel[1] > 0.0)
            vel[1] = 5000.0;
    }
}
